home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk10.zip / SCAN.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  23KB  |  835 lines
  1.  
  2. /********************************************
  3. scan.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /* $Log:    scan.c,v $
  15.  * Revision 3.7.1.1  91/09/14  17:24:11  brennan
  16.  * VERSION 1.0
  17.  * 
  18.  * Revision 3.7  91/08/13  06:52:04  brennan
  19.  * VERSION .9994
  20.  * 
  21.  * Revision 3.6  91/07/19  07:51:28  brennan
  22.  * escape sequence now recognized in command line assignments
  23.  * 
  24.  * Revision 3.5  91/06/29  09:47:27  brennan
  25.  * Only track NR if needed
  26.  * 
  27.  * Revision 3.4  91/06/28  04:17:31  brennan
  28.  * VERSION 0.999
  29.  * 
  30.  * Revision 3.3  91/06/24  07:18:40  brennan
  31.  * no longer recognize \'
  32.  * 
  33.  * Revision 3.2  91/06/15  09:05:16  brennan
  34.  * some casting of [unsigned] char* to make gcc happy
  35.  * 
  36.  * Revision 3.1  91/06/07  10:28:15  brennan
  37.  * VERSION 0.995
  38.  * 
  39.  * Revision 2.9  91/06/06  09:42:08  brennan
  40.  * added HAVE_FCNTL
  41.  * 
  42.  * Revision 2.8  91/06/04  06:47:34  brennan
  43.  * removed <string.h>
  44.  * 
  45.  * Revision 2.7  91/06/03  07:51:21  brennan
  46.  * added work around for sun4, 4.0.3, strtod() bug
  47.  * scanner eats semi-colons in outer blocks for compatibility
  48.  * 
  49.  * Revision 2.6  91/05/29  14:26:09  brennan
  50.  * -V option for version
  51.  * 
  52.  * Revision 2.5  91/05/28  15:18:13  brennan
  53.  * removed STRING_BUFF back to temp_buff.string_buff
  54.  * 
  55.  * Revision 2.4  91/05/28  09:05:11  brennan
  56.  * removed main_buff
  57.  * 
  58.  * Revision 2.3  91/04/29  07:47:23  brennan
  59.  * INC_or_DEC to support grammar changes
  60.  * 
  61.  * Revision 2.2  91/04/09  12:39:27  brennan
  62.  * added static to funct decls to satisfy STARDENT compiler
  63.  * 
  64.  * Revision 2.1  91/04/08  08:23:51  brennan
  65.  * VERSION 0.97
  66.  * 
  67. */
  68.  
  69.  
  70. #include  "mawk.h"
  71. #include  "sizes.h"
  72. #include  "scan.h"
  73. #include  "memory.h"
  74. #include  "field.h"
  75. #include  "init.h"
  76. #include  "fin.h"
  77. #include  "repl.h"
  78.  
  79. #if HAVE_FCNTL_H
  80. #include  <fcntl.h>
  81. #endif
  82.  
  83. #include  "files.h"
  84.  
  85.  
  86. /* static functions */
  87. static void PROTO(buff_create, (char *) ) ;
  88. static int PROTO(slow_next, (void) ) ;
  89. static void PROTO(eat_comment, (void) ) ;
  90. static void PROTO(eat_semi_colon, (void) ) ;
  91. static double PROTO(collect_decimal, (int, int *) ) ;
  92. static int PROTO(collect_string, (void) ) ;
  93. static int  PROTO(collect_RE, (void) ) ;
  94.  
  95. extern  short  NR_reference ;
  96.  
  97. /*-----------------------------
  98.   program file management
  99.  *----------------------------*/
  100.  
  101. static  unsigned char *buffer ;
  102. static  unsigned char *buffp ;  
  103.     /* unsigned so it works with 8 bit chars */
  104. static  int  program_fd = -1  ; 
  105. static  int  eof_flag ;
  106.  
  107.  
  108. static void buff_create(s)
  109.   char *s ;
  110. {
  111.   /* If program_fd == -1, program came from command line and s
  112.      is it, else s is a filename */
  113.  
  114.   if ( program_fd == -1 )
  115.   { buffer = buffp = (unsigned char *) s ; eof_flag = 1 ; }
  116.   else /* s is a filename, open it */
  117.   {
  118.     if ( s[0] == '-' && s[1] == 0 ) program_fd = 0 ;
  119.     else
  120. #ifdef THINK_C
  121.     if ( (program_fd = open(s, O_RDONLY)) == -1 )
  122. #else
  123.     if ( (program_fd = open(s, O_RDONLY, 0)) == -1 )
  124. #endif
  125.     { errmsg( errno, "cannot open %s", s) ; mawk_exit(1) ; }
  126.  
  127.     buffp = buffer = (unsigned char *) zmalloc( BUFFSZ+1 ) ;
  128.  
  129.     eof_flag = fillbuff(program_fd, (char *) buffer, BUFFSZ) < BUFFSZ ;
  130.   }
  131. }
  132.  
  133. void scan_cleanup()
  134. { 
  135.   if ( program_fd >= 0 ) zfree(buffer, BUFFSZ+1) ;
  136.   if ( program_fd > 0 )  (void) close(program_fd) ;
  137.   /* redefine SPACE as [ \t\r\n] */
  138.   scan_code['\n'] = SC_SPACE ;
  139.   scan_code['\f'] = SC_UNEXPECTED ; /*value doesn't matter */
  140.   scan_code['\013'] = SC_UNEXPECTED ;
  141. }
  142.  
  143.  
  144. void  scan_init(flag, p)
  145.   int flag ; /* on if program is from the command line */
  146.   char *p ;
  147. { 
  148.   if ( ! flag ) program_fd = 0 ;
  149.   buff_create(p) ;
  150.  
  151.   eat_nl() ; /* scan to first token */
  152.   if ( next() == 0 )  
  153.   { errmsg(0, "no program") ; mawk_exit(1) ; }
  154.   un_next() ;
  155. }
  156.  
  157. /*--------------------------------
  158.   global variables shared by yyparse() and yylex()
  159.  *-------------------------------*/
  160.  
  161. int  current_token = -1 ; 
  162. unsigned  token_lineno ;
  163. unsigned  compile_error_count ;
  164. int   paren_cnt ;
  165. int   brace_cnt ;
  166. int   print_flag ;  /* changes meaning of '>' */
  167. int   getline_flag ; /* changes meaning of '<' */
  168.  
  169. extern  YYSTYPE  yylval ;
  170.  
  171. /*----------------------------------------
  172.  file reading functions
  173.  next() and un_next(c) are macros in scan.h
  174.  
  175.  *---------------------*/
  176.  
  177. static  unsigned lineno = 1 ;
  178.  
  179. /* used to help distinguish / as divide or start of RE  */
  180.  
  181. static int can_precede_re[] =
  182. { MATCH, NOT_MATCH, COMMA, RBRACE, 
  183. LPAREN, NOT, P_OR, P_AND, NL,  -1 } ;
  184.  
  185. /* read one character -- slowly */
  186. static int slow_next()
  187. { 
  188.   if ( *buffp == 0  )
  189.       if ( !eof_flag ) 
  190.       { buffp = buffer ;
  191.         eof_flag = fillbuff(program_fd, (char *)buffer,BUFFSZ) < BUFFSZ ;
  192.       }
  193.  
  194.   return *buffp++ ; /* note can un_next() , eof which is zero */
  195. }
  196.  
  197. static void eat_comment()
  198. { register int c ;
  199.  
  200.   while ( (c = next()) != '\n' && scan_code[c] ) ;
  201.   un_next() ;
  202. }
  203.  
  204. /* this is how we handle extra semi-colons that are
  205.    now allowed to separate pattern-action blocks
  206.  
  207.    A proof that they are useless clutter to the language:
  208.    we throw them away
  209. */
  210.  
  211. static  void  eat_semi_colon()
  212. /* eat one semi-colon on the current line */
  213. { register int c ;
  214.  
  215.   while ( scan_code[c = next()] == SC_SPACE )  ;
  216.   if ( c != ';' )  un_next() ;
  217. }
  218.  
  219. void eat_nl() /* eat all space including newlines */
  220. {
  221.   while ( 1 )
  222.     switch( scan_code[next()] )
  223.     { 
  224.       case SC_COMMENT : 
  225.          eat_comment() ;
  226.          break ;
  227.          
  228.       case  SC_NL  :   lineno++ ;
  229.       /* fall thru  */
  230.       case  SC_SPACE  :   break ;
  231.       default :  
  232.           un_next() ; return ;
  233.     }
  234. }
  235.  
  236. int yylex()
  237. { 
  238.   register int c ;
  239.  
  240.   token_lineno = lineno ;
  241.  
  242. reswitch:
  243.  
  244.     switch( scan_code[c = next()] )
  245.     {
  246.       case  0  :  /* if no terminator on the line put one */
  247.           if ( (c = current_token) == RBRACE ||
  248.                 c == NL || c == SEMI_COLON ) ct_ret(EOF) ;
  249.           else
  250.           { un_next() ;  ct_ret(NL) ; }
  251.           
  252.       case  SC_SPACE  :   goto reswitch ;
  253.  
  254.       case  SC_COMMENT :
  255.           eat_comment() ; goto reswitch ;
  256.  
  257.       case  SC_NL  : 
  258.           lineno++ ; eat_nl() ;
  259.           ct_ret(NL) ;
  260.  
  261.       case SC_ESCAPE :
  262.           while ( scan_code[ c = next() ] == SC_SPACE ) ;
  263.           if ( c == '\n')
  264.           { token_lineno = ++lineno ; goto reswitch ; }
  265.           if ( c == 0 )  ct_ret(EOF) ;
  266.           un_next() ;
  267.           yylval.ival = '\\' ;
  268.           ct_ret(UNEXPECTED) ;
  269.  
  270.  
  271.       case  SC_SEMI_COLON  : 
  272.           eat_nl() ;
  273.           ct_ret(SEMI_COLON) ;
  274.  
  275.       case  SC_LBRACE :  
  276.           eat_nl() ; brace_cnt++ ;
  277.           ct_ret(LBRACE) ;
  278.  
  279.       case  SC_PLUS  :
  280.           switch( next() )
  281.           {
  282.             case '+' :  
  283.                 yylval.ival = '+' ;
  284.                 temp_buff.string_buff[0] = 
  285.                      temp_buff.string_buff[1] = '+' ;
  286.                 temp_buff.string_buff[2] = 0 ;
  287.                 ct_ret(INC_or_DEC) ;
  288.  
  289.             case  '=' :
  290.                 ct_ret(ADD_ASG) ;
  291.  
  292.             default :  un_next() ; ct_ret(PLUS) ;
  293.           }
  294.  
  295.       case  SC_MINUS :
  296.           switch( next() )
  297.           {
  298.             case '-' :  
  299.                 yylval.ival = '-' ;
  300.                 temp_buff.string_buff[0] = 
  301.                      temp_buff.string_buff[1] = '-' ;
  302.                 temp_buff.string_buff[2] = 0 ;
  303.                 ct_ret(INC_or_DEC) ;
  304.  
  305.             case  '=' :
  306.                 ct_ret(SUB_ASG) ;
  307.  
  308.             default :  un_next() ; ct_ret(MINUS) ;
  309.           }
  310.  
  311.       case  SC_COMMA :  eat_nl() ; ct_ret(COMMA) ;
  312.  
  313.       case  SC_MUL  :  test1_ret('=', MUL_ASG, MUL) ;
  314.       case  SC_DIV :   
  315.           { int *p = can_precede_re ;
  316.  
  317.             do
  318.                 if ( *p == current_token )
  319.                     ct_ret( collect_RE() ) ;
  320.             while ( *p++ != -1 ) ;
  321.  
  322.             test1_ret( '=', DIV_ASG , DIV ) ;
  323.           }
  324.  
  325.       case  SC_MOD  :  test1_ret('=', MOD_ASG, MOD) ;
  326.       case  SC_POW :   test1_ret('=' , POW_ASG, POW) ;
  327.       case  SC_LPAREN : 
  328.           paren_cnt++ ;
  329.           ct_ret(LPAREN) ;
  330.  
  331.       case  SC_RPAREN : 
  332.           if ( --paren_cnt < 0 )
  333.           { compile_error( "extra ')'" ) ;
  334.             paren_cnt = 0 ;
  335.             goto reswitch ; }
  336.  
  337.           ct_ret(RPAREN) ;
  338.  
  339.       case  SC_LBOX   : ct_ret(LBOX) ;
  340.       case  SC_RBOX   : ct_ret(RBOX) ;
  341.  
  342.       case  SC_MATCH  : ct_ret(MATCH) ;
  343.  
  344.       case  SC_EQUAL  :
  345.           test1_ret( '=', EQ, ASSIGN ) ;
  346.  
  347.       case  SC_NOT : /* !  */
  348.           test2_ret('=', NEQ, '~', NOT_MATCH, NOT ) ;
  349.  
  350.       case  SC_LT  :  /* '<' */
  351.           if ( getline_flag )
  352.           { getline_flag = 0 ; ct_ret(IO_IN) ; }
  353.           else
  354.           { ct_ret( ifnext('=', LTE , LT) ) ; }
  355.  
  356.       case  SC_GT  :  /* '>' */
  357.           if ( print_flag && paren_cnt == 0 )
  358.           { print_flag = 0 ;
  359.             /* there are 3 types of IO_OUT 
  360.                -- build the error string in temp_buff */
  361.             temp_buff.string_buff[0] = '>' ;
  362.             if ( next() == '>' ) 
  363.             { 
  364.               yylval.ival = F_APPEND ;
  365.               temp_buff.string_buff[1] = '>' ;
  366.               temp_buff.string_buff[2] =  0 ;
  367.             }
  368.             else
  369.             { un_next() ; 
  370.               yylval.ival = F_TRUNC ; 
  371.               temp_buff.string_buff[1] = 0 ;
  372.             }
  373.             return current_token = IO_OUT ;
  374.           }
  375.  
  376.           ct_ret( ifnext('=', GTE , GT) ) ;
  377.  
  378.       case  SC_OR :
  379.           if ( next() == '|' ) 
  380.           { eat_nl() ; ct_ret(brace_cnt?OR:P_OR) ; }
  381.           else 
  382.           { un_next() ; 
  383.  
  384.             if ( print_flag && paren_cnt == 0 )
  385.             { print_flag = 0 ; 
  386.               yylval.ival = PIPE_OUT;
  387.               temp_buff.string_buff[0] = '|' ;
  388.               temp_buff.string_buff[1] = 0 ;
  389.               ct_ret(IO_OUT) ;
  390.             }
  391.             else  ct_ret(PIPE) ;
  392.           }
  393.  
  394.       case  SC_AND :
  395.           if ( next() == '&' )  
  396.           { eat_nl() ; ct_ret(brace_cnt?AND:P_AND) ; }
  397.           else 
  398.           { un_next() ; yylval.ival = '&' ; ct_ret(UNEXPECTED) ; }
  399.  
  400.       case  SC_QMARK  :  ct_ret(QMARK) ;
  401.       case  SC_COLON  :  ct_ret(COLON) ;
  402.       case  SC_RBRACE :
  403.           if ( --brace_cnt < 0 )
  404.           { compile_error("extra '}'" ) ;
  405.             eat_semi_colon() ;
  406.             brace_cnt = 0 ; goto reswitch ; }
  407.  
  408.           if ( (c = current_token) == NL || c == SEMI_COLON 
  409.                || c == SC_FAKE_SEMI_COLON  || c == RBRACE  )
  410.           { 
  411.             /* if the brace_cnt is zero , we've completed
  412.                a pattern action block. If the user insists
  413.                on adding a semi-colon on the same line
  414.                we will eat it.  Note what we do below:
  415.                physical law -- conservation of semi-colons */
  416.  
  417.             if ( brace_cnt == 0 )  eat_semi_colon() ;
  418.             eat_nl() ;
  419.             ct_ret(RBRACE) ;
  420.           }
  421.  
  422.           /* supply missing semi-colon to statement that
  423.              precedes a '}' */
  424.           brace_cnt++ ; un_next() ;
  425.           current_token = SC_FAKE_SEMI_COLON ;
  426.           return  SEMI_COLON ;
  427.  
  428.       case  SC_DIGIT  :
  429.       case  SC_DOT    :
  430.           { double d ;
  431.             int flag ;
  432.  
  433.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  434.                 if ( flag )  ct_ret(flag) ;
  435.                 else  yylval.cp = &cell_zero ;
  436.             else if ( d == 1.0 ) yylval.cp = &cell_one ;
  437.             else 
  438.             { yylval.cp = new_CELL() ;
  439.               yylval.cp->type = C_DOUBLE ;
  440.               yylval.cp->dval = d ; 
  441.             }
  442.             ct_ret( CONSTANT ) ;
  443.           }
  444.  
  445.       case  SC_DOLLAR :  /* '$' */
  446.           { double d ;
  447.             int flag ;
  448.  
  449.             while ( scan_code[c = next()] == SC_SPACE )  ;
  450.             if ( scan_code[c] != SC_DIGIT &&
  451.                  scan_code[c] != SC_DOT )
  452.             { un_next() ; ct_ret(DOLLAR) ; }
  453.             /* compute field address at compile time */
  454.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  455.                 if ( flag )  ct_ret(flag) ; /* an error */
  456.                 else  yylval.cp = &field[0] ;
  457.             else
  458.             { int k = (int) d ;
  459.  
  460.               if ( k > MAX_FIELD )
  461.               { compile_error(
  462.                    "maximum field index(%d) exceeded" , k ) ;
  463.                 k = MAX_FIELD ;
  464.               }
  465.               else  yylval.cp = &field[k] ;
  466.             }
  467.  
  468.             ct_ret(FIELD) ;
  469.           }
  470.  
  471.       case  SC_DQUOTE :
  472.           return current_token = collect_string() ;
  473.  
  474.       case  SC_IDCHAR : /* collect an identifier */
  475.             { unsigned char *p =
  476.                     (unsigned char *)temp_buff.string_buff + 1 ;
  477.               SYMTAB *stp ;
  478.  
  479.               temp_buff.string_buff[0] = c ;
  480.  
  481.               while ( 
  482.                 (c = scan_code[ *p++ = next()]) == SC_IDCHAR ||
  483.                        c == SC_DIGIT )  ;
  484.               
  485.               un_next() ; * --p = 0 ;
  486.  
  487.               switch( (stp = find(temp_buff.string_buff))->type )
  488.               { case ST_NONE :  
  489.                   /* check for function call before defined */
  490.                       if ( next() == '(' )
  491.                       { stp->type = ST_FUNCT ;
  492.                         stp->stval.fbp = (FBLOCK *)
  493.                                 zmalloc(sizeof(FBLOCK)) ;
  494.                         stp->stval.fbp->name = stp->name ;
  495.                         stp->stval.fbp->code = (INST *) 0 ;
  496.                         yylval.fbp = stp->stval.fbp ;
  497.                         current_token = FUNCT_ID ;
  498.                       }
  499.                       else
  500.                       { yylval.stp = stp ;
  501.                         current_token = ID ;
  502.                       }
  503.                       un_next() ;
  504.                       break ;
  505.  
  506.             case  ST_NR  :
  507.               NR_reference = 1 ;
  508.               stp->type = ST_VAR ;
  509.               /* fall thru */
  510.                         
  511.                 case ST_VAR :
  512.                 case  ST_ARRAY :
  513.                 case  ST_LOCAL_NONE :
  514.                 case  ST_LOCAL_VAR :
  515.                 case  ST_LOCAL_ARRAY :
  516.  
  517.                       yylval.stp = stp ;
  518.                       current_token = ID ;
  519.                       break ;
  520.  
  521.                 case ST_FUNCT :
  522.                       yylval.fbp = stp->stval.fbp ;
  523.                       current_token = FUNCT_ID ;
  524.                       break ;
  525.  
  526.                 case ST_KEYWORD :  
  527.                       current_token = stp->stval.kw ;
  528.                       break ;
  529.  
  530.                 case  ST_BUILTIN :
  531.                       yylval.bip = stp->stval.bip ;
  532.                       current_token = BUILTIN ;
  533.                       break ;
  534.  
  535.                 case  ST_FIELD  :
  536.                       yylval.cp = stp->stval.cp ;
  537.                       current_token = FIELD ;
  538.                       break ;
  539.  
  540.                 case  ST_LENGTH  :
  541.                     { CELL *bi_length() ;
  542.                       static BI_REC length_bi_rec =
  543.                       { "length", bi_length, 1, 1 } ;
  544.  
  545.                       while ( scan_code[ c = next() ] == SC_SPACE ) ;
  546.                       un_next() ;
  547.  
  548.                       if ( c == '(' )
  549.                       { yylval.bip = &length_bi_rec ;
  550.                         current_token = BUILTIN ;
  551.                       }
  552.                       else current_token = LENGTH ;
  553.                     }
  554.                     break ;
  555.  
  556.                 default : 
  557.                       bozo("find returned bad st type") ;
  558.               }
  559.               return  current_token  ;
  560.             }
  561.  
  562.  
  563.       case  SC_UNEXPECTED :
  564.             yylval.ival = c & 0xff ;
  565.             ct_ret(UNEXPECTED) ;
  566.     }
  567.     return  0 ; /* never get here make lint happy */
  568. }
  569.  
  570. /* collect a decimal constant in temp_buff.
  571.    Return the value and error conditions by reference */
  572.  
  573. static double collect_decimal(c, flag)
  574.   int c ; int *flag ;
  575. { register unsigned char *p = (unsigned char*) temp_buff.string_buff + 1;
  576.   unsigned char *endp ;
  577.   double d ;
  578.  
  579.   *flag = 0 ;
  580.   temp_buff.string_buff[0] = c ;
  581.  
  582.   if ( c == '.' )
  583.   { if ( scan_code[*p++ = next()] != SC_DIGIT )
  584.     { *flag = UNEXPECTED ; yylval.ival = '.' ;
  585.       return 0.0 ; }
  586.   }
  587.   else
  588.   {  while ( scan_code[*p++ = next()] == SC_DIGIT ) ;
  589.      if ( p[-1] != '.' )
  590.      { un_next() ; p-- ; }
  591.   }
  592.   /* get rest of digits after decimal point */
  593.   while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  594.  
  595.   /* check for exponent */
  596.   if ( p[-1] != 'e' && p[-1] != 'E' )
  597.   { un_next() ; * --p = 0 ; }
  598.   else  /* get the exponent */
  599.     if ( scan_code[*p = next()] != SC_DIGIT &&
  600.          *p != '-' && *p != '+' )
  601.     { *++p = 0 ; *flag = BAD_DECIMAL ;
  602.       return 0.0 ; }
  603.     else  /* get the rest of the exponent */
  604.     { p++ ;
  605.       while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  606.       un_next() ; * --p = 0 ;
  607.     }
  608.  
  609.   errno = 0 ; /* check for overflow/underflow */
  610.   d = strtod( temp_buff.string_buff, (char **)&endp ) ;
  611.  
  612. #ifndef  STRTOD_UNDERFLOW_ON_ZERO_BUG
  613.   if ( errno )
  614.       compile_error( "%s : decimal %sflow" , temp_buff.string_buff,
  615.         d == 0.0 ? "under" : "over") ;
  616. #else /* sun4 bug */
  617.   if ( errno && d != 0.0 )
  618.       compile_error( "%s : decimal overflow", temp_buff.string_buff) ;
  619. #endif
  620.  
  621.   if ( endp != p )
  622.   { *flag = BAD_DECIMAL ; return 0.0 ; }
  623.   return d ;
  624. }
  625.  
  626. /*----------  process escape characters ---------------*/
  627.  
  628. static char hex_val['f' - 'A' + 1] = {
  629. 10,11,12,13,14,15, 0, 0,
  630.  0, 0, 0, 0, 0, 0, 0, 0,
  631.  0, 0, 0, 0, 0, 0, 0, 0,
  632.  0, 0, 0, 0, 0, 0, 0, 0,
  633. 10,11,12,13,14,15 } ;
  634.  
  635. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  636.  
  637. #define  hex_value(x)   hex_val[(x)-'A']
  638.  
  639. #define ishex(x) (scan_code[x] == SC_DIGIT ||\
  640.                   'A' <= (x) && (x) <= 'f' && hex_value(x))
  641.  
  642. static int PROTO(octal, (char **)) ;
  643. static int PROTO(hex, (char **)) ;
  644.  
  645. /* process one , two or three octal digits
  646.    moving a pointer forward by reference */
  647. static int octal( start_p )
  648.   char **start_p ;
  649. { register char *p = *start_p ;
  650.   register unsigned x ;
  651.  
  652.   x = *p++ - '0' ;
  653.   if ( isoctal(*p) )
  654.   {
  655.     x = (x<<3) + *p++ - '0' ;
  656.     if ( isoctal(*p) )   x = (x<<3) + *p++ - '0' ;
  657.   }
  658.   *start_p = p ;
  659.   return  x & 0xff ;
  660. }
  661.  
  662. /* process one or two hex digits
  663.    moving a pointer forward by reference */
  664.  
  665. static int  hex( start_p )
  666.   char **start_p ;
  667. { register unsigned char *p = (unsigned char*) *start_p ;
  668.   register unsigned x ;
  669.   unsigned t ;
  670.  
  671.   if ( scan_code[*p] == SC_DIGIT )
  672.         x = *p++ - '0' ;
  673.   else  x = hex_value(*p++) ;
  674.  
  675.   if ( scan_code[*p] == SC_DIGIT )
  676.         x = (x<<4) + *p++ - '0' ;
  677.   else
  678.   if ( 'A' <= *p && *p <= 'f' && (t = hex_value(*p)) )
  679.   { x = (x<<4) + t ; p++ ; }
  680.  
  681.   *start_p = (char *) p ;
  682.   return x ;
  683. }
  684.  
  685. #define  ET_END     9
  686.  
  687. static struct { char in , out ; } escape_test[ET_END+1] = {
  688. 'n' , '\n',
  689. 't' , '\t',
  690. 'f' , '\f',
  691. 'b' , '\b',
  692. 'r' , '\r',
  693. 'a' , '\07',
  694. 'v' , '\013',
  695. '\\', '\\',
  696. '\"', '\"',
  697. 0 , 0 } ;
  698.  
  699.  
  700. /* process the escape characters in a string, in place . */
  701.  
  702. char *rm_escape(s)
  703.   char *s ;
  704. { register char *p, *q ;
  705.   char *t ;
  706.   int i ;
  707.  
  708.   q = p = s ;
  709.  
  710.   while ( *p )
  711.       if ( *p == '\\' )
  712.       { 
  713.     escape_test[ET_END].in = * ++p ; /* sentinal */
  714.     i = 0 ;
  715.     while ( escape_test[i].in != *p )  i++ ;
  716.  
  717.     if ( i != ET_END )  /* in table */
  718.         { 
  719.           p++ ; *q++ = escape_test[i].out ;
  720.         }
  721.         else
  722.         if ( isoctal(*p) ) 
  723.         {
  724.           t = p ;  *q++ = octal(&t) ; p = t ;
  725.         }
  726.         else
  727.         if ( *p == 'x' && ishex(*(unsigned char*)(p+1)) )
  728.         {
  729.           t = p+1 ; *q++ = hex(&t) ; p = t ;
  730.         }
  731.     else
  732.     if ( *p == 0 ) /* can only happen with command line assign */
  733.         *q++ = '\\' ;
  734.         else  /* not an escape sequence */
  735.         { 
  736.           *q++ = '\\' ; *q++ = *p++ ;
  737.         }
  738.       }
  739.       else  *q++ = *p++ ;
  740.  
  741.   *q = 0 ;
  742.   return s ;
  743. }
  744.  
  745. static  int  collect_string()
  746. { register unsigned char *p = (unsigned char *)temp_buff.string_buff ;
  747.   int c ;
  748.   int e_flag = 0 ; /* on if have an escape char */
  749.  
  750.   while ( 1 )
  751.       switch( scan_code[ *p++ = next() ] )
  752.       { case  SC_DQUOTE : /* done */
  753.               * --p = 0 ;  goto out ;
  754.  
  755.         case  SC_NL :
  756.               p[-1] = 0 ;
  757.               /* fall thru */
  758.  
  759.         case  0 :   /* unterminated string */
  760.               compile_error(
  761.               "runaway string constant \"%.10s ..." ,
  762.               temp_buff.string_buff, token_lineno ) ;
  763.               mawk_exit(1) ;
  764.  
  765.         case SC_ESCAPE :
  766.               if ( (c = next()) == '\n' )
  767.               { p-- ; lineno++ ; }
  768.               else  
  769.                 if ( c == 0 )  un_next() ;   
  770.                 else 
  771.                 { *p++ = c ; e_flag = 1 ; }
  772.  
  773.               break ;
  774.  
  775.         default : break ;
  776.       }
  777.  
  778. out:
  779.     yylval.cp = new_CELL() ;
  780.     yylval.cp->type = C_STRING ;
  781.     yylval.cp->ptr = (PTR) new_STRING(
  782.          e_flag ? rm_escape( temp_buff.string_buff ) 
  783.                 : temp_buff.string_buff ) ;
  784.     return  CONSTANT ;
  785. }
  786.  
  787.  
  788. static  int  collect_RE()
  789. { register unsigned char *p = (unsigned char*) temp_buff.string_buff ;
  790.   int c ;
  791.   STRING *sval ;
  792.  
  793.   while ( 1 )
  794.       switch( scan_code[ *p++ = next() ] )
  795.       { case  SC_DIV : /* done */
  796.               * --p = 0 ;  goto out ;
  797.  
  798.         case  SC_NL :
  799.               p[-1] = 0 ;
  800.               /* fall thru */
  801.  
  802.         case  0 :   /* unterminated re */
  803.               compile_error(
  804.               "runaway regular expression /%.10s ..." ,
  805.               temp_buff.string_buff, token_lineno ) ;
  806.               mawk_exit(1) ;
  807.  
  808.         case SC_ESCAPE :
  809.               switch( c = next() )
  810.               { case '/' :  
  811.                       p[-1] = '/' ; break ;
  812.  
  813.                 case '\n' :
  814.                       p-- ;  break ;
  815.  
  816.                 case  0   :
  817.                       un_next() ;  break ;
  818.  
  819.                 default :
  820.                       *p++ = c ; break ;
  821.               }
  822.               break ;
  823.       }
  824.  
  825. out:
  826.   /* now we've got the RE, so compile it */
  827.   sval = new_STRING( temp_buff.string_buff ) ;
  828.   yylval.cp = new_CELL() ;
  829.   yylval.cp->type = C_RE ;
  830.   yylval.cp->ptr = re_compile(sval) ;
  831.   free_STRING(sval) ;
  832.   return RE ;
  833. }
  834.  
  835.